home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 1.iso / dist / fw_ddd.idb / usr / freeware / info / ddd.info-2.z / ddd.info-2
Text File  |  2001-10-09  |  50KB  |  1,490 lines
  1. This is ddd.info, produced by makeinfo version 4.0 from ddd.texi.
  2.  
  3. INFO-DIR-SECTION Miscellaneous
  4. START-INFO-DIR-ENTRY
  5. * DDD: (ddd).                     The Data Display Debugger.
  6. END-INFO-DIR-ENTRY
  7.  
  8. DDD is a graphical front-end for GDB and other command-line debuggers.
  9.  
  10. This is the First Edition, 2001-02-01, of `Debugging with DDD' for DDD
  11. Version 3.3.1.
  12.  
  13. Copyright (C) 2001 UniversitΣt Passau
  14. Lehrstuhl fⁿr Software-Systeme
  15. Innstra▀e 33
  16. D-94032 Passau
  17. GERMANY
  18.  
  19. Distributed by
  20. Free Software Foundation, Inc.
  21. 59 Temple Place - Suite 330
  22. Boston, MA 02111-1307
  23. USA
  24.  
  25. DDD and this manual are available via the DDD WWW page
  26. (http://www.gnu.org/software/ddd/).
  27.  
  28.    Permission is granted to copy, distribute and/or modify this document
  29. under the terms of the GNU Free Documentation License, Version 1.1 or
  30. any later version published by the Free Software Foundation; with no
  31. Invariant Sections, no Front-Cover Texts and no Back-Cover Texts.  A
  32. copy of the license is included in the section entitled "GNU Free
  33. Documentation License".
  34.  
  35.    Send questions, comments, suggestions, etc. to <ddd@gnu.org>.
  36. Send bug reports to <bug-ddd@gnu.org>.
  37. 
  38. File: ddd.info,  Node: Options,  Next: X Options,  Prev: Choosing an Inferior Debugger,  Up: Invoking
  39.  
  40. DDD Options
  41. -----------
  42.  
  43.    You can further control how DDD starts up using the following
  44. options.  All options may be abbreviated, as long as they are
  45. unambiguous; single dashes `-' instead of double dashes `--' may also
  46. be used.  Almost all options control a specific DDD resource or
  47. resource class (*note Customizing::).
  48.  
  49. `--attach-windows'
  50.      Attach the source and data windows to the debugger console,
  51.      creating one single big DDD window.  This is the default setting.
  52.  
  53.      Giving this option is equivalent to setting the DDD `Separate'
  54.      resource class to `off'.  *Note Window Layout::, for details.
  55.  
  56. `--attach-source-window'
  57.      Attach only the source window to the debugger console.
  58.  
  59.      Giving this option is equivalent to setting the DDD
  60.      `separateSourceWindow' resource to `off'.  *Note Window Layout::,
  61.      for details.
  62.  
  63. `--attach-data-window'
  64.      Attach only the source window to the debugger console.
  65.  
  66.      Giving this option is equivalent to setting the DDD
  67.      `separateDataWindow' resource to `off'.  *Note Window Layout::,
  68.      for details.
  69.  
  70. `--automatic-debugger'
  71.      Determine the inferior debugger automatically from the given
  72.      arguments.
  73.  
  74.      Giving this option is equivalent to setting the DDD `autoDebugger'
  75.      resource to `on'.  *Note Customizing Debugger Interaction::, for
  76.      details.
  77.  
  78. `--button-tips'
  79.      Enable button tips.
  80.  
  81.      Giving this option is equivalent to setting the DDD `buttonTips'
  82.      resource to `on'.  *Note Customizing Help::, for details.
  83.  
  84. `--configuration'
  85.      Print the DDD configuration settings on standard output and exit.
  86.  
  87.      Giving this option is equivalent to setting the DDD
  88.      `showConfiguration' resource to `on'.  *Note Diagnostics::, for
  89.      details.
  90.  
  91. `--check-configuration'
  92.      Check the DDD environment (in particular, the X configuration),
  93.      report any possible problem causes and exit.
  94.  
  95.      Giving this option is equivalent to setting the DDD
  96.      `checkConfiguration' resource to `on'.  *Note Diagnostics::, for
  97.      details.
  98.  
  99. `--data-window'
  100.      Open the data window upon start-up.
  101.  
  102.      Giving this option is equivalent to setting the DDD
  103.      `openDataWindow' resource to `on'.  *Note Toggling Windows::, for
  104.      details.
  105.  
  106. `--dbx'
  107.      Run DBX as inferior debugger.
  108.  
  109.      Giving this option is equivalent to setting the DDD `debugger'
  110.      resource to `dbx'.  *Note Customizing Debugger Interaction::, for
  111.      details.
  112.  
  113. `--debugger NAME'
  114.      Invoke the inferior debugger NAME.  This is useful if you have
  115.      several debugger versions around, or if the inferior debugger
  116.      cannot be invoked under its usual name (i.e. `gdb', `wdb', `dbx',
  117.      `xdb', `jdb', `pydb', or `perl').
  118.  
  119.      This option can also be used to pass options to the inferior
  120.      debugger that would otherwise conflict with DDD options.  For
  121.      instance, to pass the option `-d DIRECTORY' to XDB, use:
  122.  
  123.           ddd --debugger "xdb -d DIRECTORY"
  124.  
  125.      If you use the `--debugger' option, be sure that the type of
  126.      inferior debugger is specified as well.  That is, use one of the
  127.      options `--gdb', `--dbx', `--xdb', `--jdb', `--pydb', or `--perl'
  128.      (unless the default setting works fine).
  129.  
  130.      Giving this option is equivalent to setting the DDD
  131.      `debuggerCommand' resource to NAME.  *Note Customizing Debugger
  132.      Interaction::, for details.
  133.  
  134. `--debugger-console'
  135.      Open the debugger console upon start-up.
  136.  
  137.      Giving this option is equivalent to setting the DDD
  138.      `openDebuggerConsole' resource to `on'.  *Note Toggling Windows::,
  139.      for details.
  140.  
  141. `--disassemble'
  142.      Disassemble the source code.  See also the `--no-disassemble'
  143.      option, below.
  144.  
  145.      Giving this option is equivalent to setting the DDD `disassemble'
  146.      resource to `on'.  *Note Customizing Source::, for details.
  147.  
  148. `--exec-window'
  149.      Run the debugged program in a specially created execution window.
  150.      This is useful for programs that have special terminal
  151.      requirements not provided by the debugger window, as raw keyboard
  152.      processing or terminal control sequences.  *Note Using the
  153.      Execution Window::, for details.
  154.  
  155.      Giving this option is equivalent to setting the DDD
  156.      `separateExecWindow' resource to `on'.  *Note Customizing the
  157.      Execution Window::, for details.
  158.  
  159. `--font FONTNAME'
  160. `-fn FONTNAME'
  161.      Use FONTNAME as default font.
  162.  
  163.      Giving this option is equivalent to setting the DDD `defaultFont'
  164.      resource to `fontname'.  *Note Customizing Fonts::, for details.
  165.  
  166. `--fonts'
  167.      Show the font definitions used by DDD on standard output.
  168.  
  169.      Giving this option is equivalent to setting the DDD `showFonts'
  170.      resource to `on'.  *Note Diagnostics::, for details.
  171.  
  172. `--fontsize SIZE'
  173.      Set the default font size to SIZE (in 1/10 points).  To make DDD
  174.      use 12-point fonts, say `--fontsize 120'.
  175.  
  176.      Giving this option is equivalent to setting the DDD `FontSize'
  177.      resource class to `size'.  *Note Customizing Fonts::, for details.
  178.  
  179. `--fullname'
  180. `-f'
  181.      Enable the TTY interface, taking additional debugger commands from
  182.      standard input and forwarding debugger output on standard output.
  183.      Current positions are issued in GDB `-fullname' format suitable
  184.      for debugger front-ends.  By default, both the debugger console
  185.      and source window are disabled.  *Note TTY mode::, for a
  186.      discussion.
  187.  
  188.      Giving this option is equivalent to setting the DDD `TTYMode'
  189.      resource class to `on'.  *Note TTY mode::, for details.
  190.  
  191. `--gdb'
  192.      Run GDB as inferior debugger.
  193.  
  194.      Giving this option is equivalent to setting the DDD `debugger'
  195.      resource to `gdb'.  *Note Customizing Debugger Interaction::, for
  196.      details.
  197.  
  198. `--glyphs'
  199.      Display the current execution position and breakpoints as glyphs.
  200.      See also the `--no-glyphs' option, below.
  201.  
  202.      Giving this option is equivalent to setting the DDD
  203.      `displayGlyphs' resource to `on'.  *Note Customizing Source::, for
  204.      details.
  205.  
  206. `--help'
  207. `-h'
  208. `-?'
  209.      Give a list of frequently used options.  Show options of the
  210.      inferior debugger as well.
  211.  
  212.      Giving this option is equivalent to setting the DDD
  213.      `showInvocation' resource to `on'.  *Note Diagnostics::, for
  214.      details.
  215.  
  216. `--host HOSTNAME'
  217. `--host USERNAME@HOSTNAME'
  218.      Invoke the inferior debugger directly on the remote host HOSTNAME.
  219.      If USERNAME is given and the `--login' option is not used, use
  220.      USERNAME as remote user name.  *Note Remote Debugger::, for
  221.      details.
  222.  
  223.      Giving this option is equivalent to setting the DDD `debuggerHost'
  224.      resource to HOSTNAME.  *Note Remote Debugger::, for details.
  225.  
  226. `--jdb'
  227.      Run JDB as inferior debugger.
  228.  
  229.      Giving this option is equivalent to setting the DDD `debugger'
  230.      resource to `gdb'.  *Note Customizing Debugger Interaction::, for
  231.      details.
  232.  
  233. `--ladebug'
  234.      Run Ladebug as inferior debugger.
  235.  
  236.      Giving this option is equivalent to setting the DDD `debugger'
  237.      resource to `ladebug'.  *Note Customizing Debugger Interaction::,
  238.      for details.
  239.  
  240. `--lesstif-hacks'
  241.      Equivalent to `--lesstif-version 999'.  Deprecated.
  242.  
  243.      Giving this option is equivalent to setting the DDD
  244.      `lessTifVersion' resource to `999'.  *Note LessTif::, for details.
  245.  
  246. `--lesstif-version VERSION'
  247.      Enable some hacks to make DDD run properly with LessTif.  *Note
  248.      LessTif::, for a discussion.
  249.  
  250.      Giving this option is equivalent to setting the DDD
  251.      `lessTifVersion' resource to VERSION.  *Note LessTif::, for
  252.      details.
  253.  
  254. `--license'
  255.      Print the DDD license on standard output and exit.
  256.  
  257.      Giving this option is equivalent to setting the DDD `showLicense'
  258.      resource to ON.  *Note Diagnostics::, for details.
  259.  
  260. `--login USERNAME'
  261. `-l USERNAME'
  262.      Use USERNAME as remote user name.  *Note Remote Debugger::, for
  263.      details.
  264.  
  265.      Giving this option is equivalent to setting the DDD
  266.      `debuggerHostLogin' resource to USERNAME.  *Note Remote
  267.      Debugger::, for details.
  268.  
  269. `--maintenance'
  270.      Enable the top-level `Maintenance' menu with options for debugging
  271.      DDD.  *Note Maintenance Menu::, for details.
  272.  
  273.      Giving this option is equivalent to setting the DDD `maintenance'
  274.      resource to ON.  *Note Maintenance Menu::, for details.
  275.  
  276. `--manual'
  277.      Print the DDD manual on standard output and exit.
  278.  
  279.      Giving this option is equivalent to setting the DDD `showManual'
  280.      resource to ON.  *Note Diagnostics::, for details.
  281.  
  282. `--news'
  283.      Print the DDD news on standard output and exit.
  284.  
  285.      Giving this option is equivalent to setting the DDD `showNews'
  286.      resource to ON.  *Note Diagnostics::, for details.
  287.  
  288. `--no-button-tips'
  289.      Disable button tips.
  290.  
  291.      Giving this option is equivalent to setting the DDD `buttonTips'
  292.      resource to `off'.  *Note Customizing Help::, for details.
  293.  
  294. `--no-data-window'
  295.      Do not open the data window upon start-up.
  296.  
  297.      Giving this option is equivalent to setting the DDD
  298.      `openDataWindow' resource to `off'.  *Note Toggling Windows::, for
  299.      details.
  300.  
  301. `--no-debugger-console'
  302.      Do not open the debugger console upon start-up.
  303.  
  304.      Giving this option is equivalent to setting the DDD
  305.      `openDebuggerConsole' resource to `off'.  *Note Toggling
  306.      Windows::, for details.
  307.  
  308. `--no-disassemble'
  309.      Do not disassemble the source code.
  310.  
  311.      Giving this option is equivalent to setting the DDD `disassemble'
  312.      resource to `off'.  *Note Customizing Source::, for details.
  313.  
  314. `--no-exec-window'
  315.      Do not run the debugged program in a specially created execution
  316.      window; use the debugger console instead.  Useful for programs
  317.      that have little terminal input/output, or for remote debugging.
  318.      *Note Using the Execution Window::, for details.
  319.  
  320.      Giving this option is equivalent to setting the DDD
  321.      `separateExecWindow' resource to `off'.  *Note Customizing the
  322.      Execution Window::, for details.
  323.  
  324. `--no-glyphs'
  325.      Do not use glyphs; display the current execution position and
  326.      breakpoints as text characters.
  327.  
  328.      Giving this option is equivalent to setting the DDD
  329.      `displayGlyphs' resource to `off'.  *Note Customizing Source::,
  330.      for details.
  331.  
  332. `--no-lesstif-hacks'
  333.      Equivalent to `--lesstif-version 1000'.  Deprecated.
  334.  
  335.      Giving this option is equivalent to setting the DDD
  336.      `lessTifVersion' resource to `1000'.  *Note LessTif::, for details.
  337.  
  338. `--no-maintenance'
  339.      Do not enable the top-level `Maintenance' menu with options for
  340.      debugging DDD.  This is the default.  *Note Maintenance Menu::,
  341.      for details.
  342.  
  343.      Giving this option is equivalent to setting the DDD `maintenance'
  344.      resource to OFF.  *Note Maintenance Menu::, for details.
  345.  
  346. `--no-source-window'
  347.      Do not open the source window upon start-up.
  348.  
  349.      Giving this option is equivalent to setting the DDD
  350.      `openSourceWindow' resource to `off'.  *Note Toggling Windows::,
  351.      for details.
  352.  
  353. `--no-value-tips'
  354.      Disable value tips.
  355.  
  356.      Giving this option is equivalent to setting the DDD `valueTips'
  357.      resource to `off'.  *Note Value Tips::, for details.
  358.  
  359. `--nw'
  360.      Do not use the X window interface.  Start the inferior debugger on
  361.      the local host.
  362.  
  363. `--perl'
  364.      Run Perl as inferior debugger.
  365.  
  366.      Giving this option is equivalent to setting the DDD `debugger'
  367.      resource to `perl'.  *Note Customizing Debugger Interaction::, for
  368.      details.
  369.  
  370. `--pydb'
  371.      Run PYDB as inferior debugger.
  372.  
  373.      Giving this option is equivalent to setting the DDD `debugger'
  374.      resource to `pydb'.  *Note Customizing Debugger Interaction::, for
  375.      details.
  376.  
  377. `--panned-graph-editor'
  378.      Use an Athena panner to scroll the data window.  Most people prefer
  379.      panners on scroll bars, since panners allow two-dimensional
  380.      scrolling.  However, the panner is off by default, since some
  381.      M*tif implementations do not work well with Athena widgets.  *Note
  382.      Display Resources::, for details; see also
  383.      `--scrolled-graph-editor', below.
  384.  
  385.      Giving this option is equivalent to setting the DDD
  386.      `pannedGraphEditor' resource to `on'.  *Note Display Resources::,
  387.      for details.
  388.  
  389. `--play-log LOG-FILE'
  390.      Recapitulate a previous DDD session.
  391.  
  392.           ddd --play-log LOG-FILE
  393.  
  394.      invokes DDD as inferior debugger, simulating the inferior debugger
  395.      given in LOG-FILE (see below).  This is useful for debugging DDD.
  396.  
  397.      Giving this option is equivalent to setting the DDD `playLog'
  398.      resource to `on'.  *Note Customizing Debugger Interaction::, for
  399.      details.
  400.  
  401. `--PLAY LOG-FILE'
  402.      Simulate an inferior debugger.  LOG-FILE is a `~/.ddd/log' file as
  403.      generated by some previous DDD session (*note Logging::).  When a
  404.      command is entered, scan LOG-FILE for this command and re-issue
  405.      the logged reply; if the command is not found, do nothing.  This
  406.      is used by the `--play' option.
  407.  
  408. `--rhost HOSTNAME'
  409. `--rhost USERNAME@HOSTNAME'
  410.      Run the inferior debugger interactively on the remote host
  411.      HOSTNAME.  If USERNAME is given and the `--login' option is not
  412.      used, use USERNAME as remote user name.  *Note Remote Debugger::,
  413.      for details.
  414.  
  415.      Giving this option is equivalent to setting the DDD
  416.      `debuggerRHost' resource to HOSTNAME.  *Note Remote Debugger::,
  417.      for details.
  418.  
  419. `--scrolled-graph-editor'
  420.      Use M*tif scroll bars to scroll the data window.  This is the
  421.      default in most DDD configurations.  *Note Display Resources::,
  422.      for details; see also `--panned-graph-editor', above.
  423.  
  424.      Giving this option is equivalent to setting the DDD
  425.      `pannedGraphEditor' resource to `off'.  *Note Display Resources::,
  426.      for details.
  427.  
  428. `--separate-windows'
  429. `--separate'
  430.      Separate the console, source and data windows.  See also the
  431.      `--attach' options, above.
  432.  
  433.      Giving this option is equivalent to setting the DDD `Separate'
  434.      resource class to `off'.  *Note Window Layout::, for details.
  435.  
  436. `--session SESSION'
  437.      Load SESSION upon start-up.  *Note Resuming Sessions::, for
  438.      details.
  439.  
  440.      Giving this option is equivalent to setting the DDD `session'
  441.      resource to SESSION.  *Note Resuming Sessions::, for details.
  442.  
  443. `--source-window'
  444.      Open the source window upon start-up.
  445.  
  446.      Giving this option is equivalent to setting the DDD
  447.      `openSourceWindow' resource to `on'.  *Note Toggling Windows::,
  448.      for details.
  449.  
  450. `--status-at-bottom'
  451.      Place the status line at the bottom of the source window.
  452.  
  453.      Giving this option is equivalent to setting the DDD
  454.      `statusAtBottom' resource to `on'.  *Note Window Layout::, for
  455.      details.
  456.  
  457. `--status-at-top'
  458.      Place the status line at the top of the source window.
  459.  
  460.      Giving this option is equivalent to setting the DDD
  461.      `statusAtBottom' resource to `off'.  *Note Window Layout::, for
  462.      details.
  463.  
  464. `--sync-debugger'
  465.      Do not process X events while the debugger is busy.  This may
  466.      result in slightly better performance on single-processor systems.
  467.  
  468.      Giving this option is equivalent to setting the DDD
  469.      `synchronousDebugger' resource to `on'.  *Note Customizing
  470.      Debugger Interaction::, for details.
  471.  
  472. `--toolbars-at-bottom'
  473.      Place the toolbars at the bottom of the respective window.
  474.  
  475.      Giving this option is equivalent to setting the DDD
  476.      `toolbarsAtBottom' resource to `on'.  *Note Window Layout::, for
  477.      details.
  478.  
  479. `--toolbars-at-top'
  480.      Place the toolbars at the top of the respective window.
  481.  
  482.      Giving this option is equivalent to setting the DDD
  483.      `toolbarsAtBottom' resource to `off'.  *Note Window Layout::, for
  484.      details.
  485.  
  486. `--trace'
  487.      Show the interaction between DDD and the inferior debugger on
  488.      standard error.  This is useful for debugging DDD.  If `--trace'
  489.      is not specified, this information is written into `~/.ddd/log'
  490.      (`~' stands for your home directory), such that you can also do a
  491.      post-mortem debugging.  *Note Logging::, for details about logging.
  492.  
  493.      Giving this option is equivalent to setting the DDD `trace'
  494.      resource to ON.  *Note Diagnostics::, for details.
  495.  
  496. `--tty'
  497. `-t'
  498.      Enable TTY interface, taking additional debugger commands from
  499.      standard input and forwarding debugger output on standard output.
  500.      Current positions are issued in a format readable for humans.  By
  501.      default, the debugger console is disabled.
  502.  
  503.      Giving this option is equivalent to setting the DDD `ttyMode'
  504.      resource to `on'.  *Note TTY mode::, for details.
  505.  
  506. `--value-tips'
  507.      Enable value tips.
  508.  
  509.      Giving this option is equivalent to setting the DDD `valueTips'
  510.      resource to `on'.  *Note Value Tips::, for details.
  511.  
  512. `--version'
  513. `-v'
  514.      Print the DDD version on standard output and exit.
  515.  
  516.      Giving this option is equivalent to setting the DDD `showVersion'
  517.      resource to `on'.  *Note Diagnostics::, for details.
  518.  
  519. `--vsl-library LIBRARY'
  520.      Load the VSL library LIBRARY instead of using the DDD built-in
  521.      library.  This is useful for customizing display shapes and fonts.
  522.  
  523.      Giving this option is equivalent to setting the DDD `vslLibrary'
  524.      resource to LIBRARY.  *Note VSL Resources::, for details.
  525.  
  526. `--vsl-path PATH'
  527.      Search VSL libraries in PATH (a colon-separated directory list).
  528.  
  529.      Giving this option is equivalent to setting the DDD `vslPath'
  530.      resource to PATH.  *Note VSL Resources::, for details.
  531.  
  532. `--vsl-help'
  533.      Show a list of further options controlling the VSL interpreter.
  534.      These options are intended for debugging purposes and are subject
  535.      to change without further notice.
  536.  
  537. `--wdb'
  538.      Run WDB as inferior debugger.
  539.  
  540.      Giving this option is equivalent to setting the DDD `debugger'
  541.      resource to `wdb'.  *Note Customizing Debugger Interaction::, for
  542.      details.
  543.  
  544. `--xdb'
  545.      Run XDB as inferior debugger.
  546.  
  547.      Giving this option is equivalent to setting the DDD `debugger'
  548.      resource to `xdb'.  *Note Customizing Debugger Interaction::, for
  549.      details.
  550.  
  551. 
  552. File: ddd.info,  Node: X Options,  Next: Inferior Debugger Options,  Prev: Options,  Up: Invoking
  553.  
  554. X Options
  555. ---------
  556.  
  557.    DDD also understands the following X options.  Note that these
  558. options only take a single dash `-'.
  559.  
  560. `-display DISPLAY'
  561.      Use the X server DISPLAY.  By default, DISPLAY is taken from the
  562.      `DISPLAY' environment variable.
  563.  
  564. `-geometry GEOMETRY'
  565.      Specify the initial size and location of the debugger console.
  566.  
  567. `-iconic'
  568.      Start DDD iconified.
  569.  
  570. `-name NAME'
  571.      Give DDD the name NAME.
  572.  
  573. `-selectionTimeout TIMEOUT'
  574.      Specify the timeout in milliseconds within which two communicating
  575.      applications must respond to one another for a selection request.
  576.  
  577. `-title NAME'
  578.      Give the DDD window the title NAME.
  579.  
  580. `-xrm RESOURCESTRING'
  581.      Specify a resource name and value to override any defaults.
  582.  
  583. 
  584. File: ddd.info,  Node: Inferior Debugger Options,  Next: Multiple Instances,  Prev: X Options,  Up: Invoking
  585.  
  586. Inferior Debugger Options
  587. -------------------------
  588.  
  589.    All options that DDD does not recognize are passed to the inferior
  590. debugger.  This section lists the most useful options of the different
  591. inferior debuggers supported by DDD.
  592.  
  593. * Menu:
  594.  
  595. * GDB Options::
  596. * DBX and Ladebug Options::
  597. * XDB Options::
  598. * JDB Options::
  599. * PYDB Options::
  600. * Perl Options::
  601.  
  602. 
  603. File: ddd.info,  Node: GDB Options,  Next: DBX and Ladebug Options,  Up: Inferior Debugger Options
  604.  
  605. GDB Options
  606. ...........
  607.  
  608.    These GDB options are useful when using DDD with GDB as inferior
  609. debugger.  Single dashes `-' instead of double dashes `--' may also be
  610. used.
  611.  
  612. `-b BAUDRATE'
  613.      Set serial port baud rate used for remote debugging.
  614.  
  615. `--cd DIR'
  616.      Change current directory to DIR.
  617.  
  618. `--command FILE'
  619.      Execute GDB commands from FILE.
  620.  
  621. `--core COREFILE'
  622.      Analyze the core dump COREFILE.
  623.  
  624. `--directory DIR'
  625. `-d DIR'
  626.      Add DIRECTORY to the path to search for source files.
  627.  
  628. `--exec EXECFILE'
  629.      Use EXECFILE as the executable.
  630.  
  631. `--mapped'
  632.      Use mapped symbol files if supported on this system.
  633.  
  634. `--nx'
  635.  
  636. `-n'
  637.      Do not read `.gdbinit' file.
  638.  
  639. `--readnow'
  640.      Fully read symbol files on first access.
  641.  
  642. `--se FILE'
  643.      Use FILE as symbol file and executable file.
  644.  
  645. `--symbols SYMFILE'
  646.      Read symbols from SYMFILE.
  647.  
  648.    *Note Invoking GDB: (gdb)Invoking GDB, for further options that can
  649. be used with GDB.
  650.  
  651. 
  652. File: ddd.info,  Node: DBX and Ladebug Options,  Next: XDB Options,  Prev: GDB Options,  Up: Inferior Debugger Options
  653.  
  654. DBX and Ladebug Options
  655. .......................
  656.  
  657.    DBX variants differ widely in their options, so we cannot give a list
  658. here.  Check out the `dbx(1)' and `ladebug(1)' manual pages.
  659.  
  660. 
  661. File: ddd.info,  Node: XDB Options,  Next: JDB Options,  Prev: DBX and Ladebug Options,  Up: Inferior Debugger Options
  662.  
  663. XDB Options
  664. ...........
  665.  
  666.    These XDB options are useful when using DDD with XDB as inferior
  667. debugger.
  668.  
  669. `-d DIR'
  670.      Specify DIR as an alternate directory where source files are
  671.      located.
  672.  
  673. `-P PROCESS-ID'
  674.      Specify the process ID of an existing process the user wants to
  675.      debug.
  676.  
  677. `-l LIBRARY'
  678.      Pre-load information about the shared library LIBRARY.  `-l ALL'
  679.      means always pre-load shared library information.
  680.  
  681. `-S NUM'
  682.      Set the size of the string cache to NUM bytes (default is 1024,
  683.      which is also the minimum).
  684.  
  685. `-s'
  686.      Enable debugging of shared libraries.
  687.  
  688.    Further options can be found in the `xdb(1)' manual page.
  689.  
  690. 
  691. File: ddd.info,  Node: JDB Options,  Next: PYDB Options,  Prev: XDB Options,  Up: Inferior Debugger Options
  692.  
  693. JDB Options
  694. ...........
  695.  
  696. JDB as of JDK 1.2
  697. .................
  698.  
  699.    The following JDB options are useful when using DDD with JDB (from
  700. JDK 1.2) as inferior debugger.
  701.  
  702. `-attach ADDRESS'
  703.      attach to a running virtual machine (VM) at ADDRESS using standard
  704.      connector
  705.  
  706. `-listen ADDRESS'
  707.      wait for a running VM to connect at ADDRESS using standard
  708.      connector
  709.  
  710. `-listenany'
  711.      wait for a running VM to connect at any available address using
  712.      standard connector
  713.  
  714. `-launch'
  715.      launch VM immediately instead of waiting for `run' command
  716.  
  717.    These JDB options are forwarded to the debuggee:
  718.  
  719. `-verbose[:class|gc|jni]'
  720. `-v'
  721.      Turn on verbose mode.
  722.  
  723. `-DNAME=VALUE'
  724.      Set the system property NAME to VALUE.
  725.  
  726. `-classpath PATH'
  727.      List directories in which to look for classes.  PATH is a list of
  728.      directories separated by colons.
  729.  
  730. `-X OPTION'
  731.      Non-standard target VM option
  732.  
  733. JDB as of JDK 1.1
  734. .................
  735.  
  736.    The following JDB options are useful when using DDD with JDB (from
  737. JDK 1.1) as inferior debugger.
  738.  
  739. `-host HOSTNAME'
  740.      host machine of interpreter to attach to
  741.  
  742. `-password PSSWD'
  743.      password of interpreter to attach to (from `-debug')
  744.  
  745.    These JDB options are forwarded to the debuggee:
  746.  
  747. `-verbose'
  748. `-v'
  749.      Turn on verbose mode.
  750.  
  751. `-debug'
  752.      Enable remote Java debugging,
  753.  
  754. `-noasyncgc'
  755.      Don't allow asynchronous garbage collection.
  756.  
  757. `-verbosegc'
  758.      Print a message when garbage collection occurs.
  759.  
  760. `-noclassgc'
  761.      Disable class garbage collection.
  762.  
  763. `-checksource'
  764. `-cs'
  765.      Check if source is newer when loading classes.
  766.  
  767. `-ss NUMBER'
  768.      Set the maximum native stack size for any thread.
  769.  
  770. `-oss NUMBER'
  771.      Set the maximum Java stack size for any thread.
  772.  
  773. `-ms NUMBER'
  774.      Set the initial Java heap size.
  775.  
  776. `-mx NUMBER'
  777.      Set the maximum Java heap size.
  778.  
  779. `-DNAME=VALUE'
  780.      Set the system property NAME to VALUE.
  781.  
  782. `-classpath PATH'
  783.      List directories in which to look for classes.  PATH is a list of
  784.      directories separated by colons.
  785.  
  786. `-prof'
  787. `-prof:FILE'
  788.      Output profiling data to `./java.prof'.  If FILE is given, write
  789.      the data to `./FILE'.
  790.  
  791. `-verify'
  792.      Verify all classes when read in.
  793.  
  794. `-verifyremote'
  795.      Verify classes read in over the network (default).
  796.  
  797. `-noverify'
  798.      Do not verify any class.
  799.  
  800. `-dbgtrace'
  801.      Print info for debugging JDB.
  802.  
  803.    Further options can be found in the JDB documentation.
  804.  
  805. 
  806. File: ddd.info,  Node: PYDB Options,  Next: Perl Options,  Prev: JDB Options,  Up: Inferior Debugger Options
  807.  
  808. PYDB Options
  809. ............
  810.  
  811.    For a list of useful PYDB options, check out the PYDB documentation.
  812.  
  813. 
  814. File: ddd.info,  Node: Perl Options,  Prev: PYDB Options,  Up: Inferior Debugger Options
  815.  
  816. Perl Options
  817. ............
  818.  
  819.    The most important Perl option to use with DDD is `-w'; it enables
  820. several important warnings.  For further options, see the `perlrun(1)'
  821. manual page.
  822.  
  823. 
  824. File: ddd.info,  Node: Multiple Instances,  Next: X Warnings,  Prev: Inferior Debugger Options,  Up: Invoking
  825.  
  826. Multiple DDD Instances
  827. ----------------------
  828.  
  829.    If you have multiple DDD instances running, they share common
  830. preferences and history files.  This means that changes applied to one
  831. instance may get lost when being overwritten by the other instance.
  832. DDD has two means to protect you against unwanted losses.  The first
  833. means is an automatic reloading of changed options, controlled by the
  834. following resource (*note Customizing::):
  835.  
  836.  - Resource: checkOptions (class CheckOptions)
  837.      Every N seconds, where N is the value of this resource, DDD checks
  838.      whether the options file has changed.  Default is `30', which
  839.      means that every 30 seconds, DDD checks for the options file.
  840.      Setting this resource to `0' disables checking for changed option
  841.      files.
  842.  
  843.    Normally, automatic reloading of options should already suffice.  If
  844. you need stronger protection, DDD also provides a warning against
  845. multiple instances.  This warning is disabled by default, If you want to
  846. be warned about multiple DDD invocations sharing the same preferences
  847. and history files, enable `Edit => Preferences => Warn if Multiple DDD
  848. Instances are Running'.
  849.  
  850.    This setting is tied to the following resource (*note Customizing::):
  851.  
  852.  - Resource: warnIfLocked (class WarnIfLocked)
  853.      Whether to warn if multiple DDD instances are running (`on') or
  854.      not (`off', default).
  855.  
  856. 
  857. File: ddd.info,  Node: X Warnings,  Prev: Multiple Instances,  Up: Invoking
  858.  
  859. X warnings
  860. ----------
  861.  
  862.    If you are bothered by X warnings, you can suppress them by setting
  863. `Edit => Preferences => General => Suppress X warnings'.
  864.  
  865.    This setting is tied to the following resource (*note Customizing::):
  866.  
  867.  - Resource: suppressWarnings (class SuppressWarnings)
  868.      If `on', X warnings are suppressed.  This is sometimes useful for
  869.      executables that were built on a machine with a different X or
  870.      M*tif configuration.  By default, this is `off'.
  871.  
  872. 
  873. File: ddd.info,  Node: Quitting,  Next: Sessions,  Prev: Invoking,  Up: Invocation
  874.  
  875. Quitting DDD
  876. ============
  877.  
  878.    To exit DDD, select `File => Exit'.  You may also type the `quit'
  879. command at the debugger prompt or press <Ctrl+Q>.  GDB and XDB also
  880. accept the `q' command or an end-of-file character (usually <Ctrl+D>).
  881. Closing the last DDD window will also exit DDD.
  882.  
  883.    An interrupt (<ESC> or `Interrupt') does not exit from DDD, but
  884. rather terminates the action of any debugger command that is in
  885. progress and returns to the debugger command level.  It is safe to type
  886. the interrupt character at any time because the debugger does not allow
  887. it to take effect until a time when it is safe.
  888.  
  889.    In case an ordinary interrupt does not succeed, you can also use an
  890. abort (<Ctrl+\> or `Abort'), which sends a `SIGABRT' signal to the
  891. inferior debugger.  Use this in emergencies only; the inferior debugger
  892. may be left inconsistent or even exit after a `SIGABRT' signal.
  893.  
  894.    As a last resort (if DDD hangs, for example), you may also interrupt
  895. DDD itself using an interrupt signal (`SIGINT').  This can be done by
  896. typing the interrupt character (usually <Ctrl+C>) in the shell DDD was
  897. started from, or by using the UNIX `kill' command.  An interrupt signal
  898. interrupts any DDD action; the inferior debugger is interrupted as
  899. well.  Since this interrupt signal can result in internal
  900. inconsistencies, use this as a last resort in emergencies only; save
  901. your work as soon as possible and restart DDD.
  902.  
  903. 
  904. File: ddd.info,  Node: Sessions,  Next: Remote Debugging,  Prev: Quitting,  Up: Invocation
  905.  
  906. Persistent Sessions
  907. ===================
  908.  
  909.    If you want to interrupt your current DDD session, you can save the
  910. entire the entire DDD state as "session" on disk and resume later.
  911.  
  912. * Menu:
  913.  
  914. * Saving Sessions::
  915. * Resuming Sessions::
  916. * Deleting Sessions::
  917. * Customizing Sessions::
  918.  
  919. 
  920. File: ddd.info,  Node: Saving Sessions,  Next: Resuming Sessions,  Up: Sessions
  921.  
  922. Saving Sessions
  923. ---------------
  924.  
  925.    To save a session, select `File => Save Session As'.  You will be
  926. asked for a symbolic session name SESSION.
  927.  
  928.    If your program is running (*note Running::), or if you have opened a
  929. core file (*note Opening Core Dumps::), DDD can also include a core
  930. file in the session such that the debuggee data will be restored when
  931. re-opening it.  To get a core file, DDD typically must "kill" the
  932. debuggee.  This means that you cannot resume program execution after
  933. saving a session.  Depending on your architecture, other options for
  934. getting a core file may also be available.
  935.  
  936.    Including a core dump is necessary for restoring memory contents and
  937. the current execution position.  To include a core dump, enable
  938. `Include Core Dump'.
  939.  
  940.    After clicking on `Save', the session is saved in
  941. `~/.ddd/sessions/SESSION'.
  942.  
  943.    Here's a list of the items whose state is saved in a session:
  944.    * The state of the debugged program, as a core file.(1)
  945.  
  946.    * All breakpoints and watchpoints (*note Stopping::).
  947.  
  948.    * All signal settings (*note Signals::).
  949.  
  950.    * All displays (*note Displaying Values::).(2)
  951.  
  952.    * All DDD options (*note Saving Options::).
  953.  
  954.    * All debugger settings (*note Debugger Settings::).
  955.  
  956.    * All user-defined buttons (*note Defining Buttons::).
  957.  
  958.    * All user-defined commands (*note Defining Commands::).
  959.  
  960.    * The positions and sizes of DDD windows.
  961.  
  962.    * The command history (*note Command History::).
  963.  
  964.    After saving the current state as a session, the session becomes
  965. "active".  This means that DDD state will be saved as session defaults:
  966.  
  967.    * User options will be saved in `~/.ddd/sessions/SESSION/init'
  968.      instead of `~/.ddd/init'.  *Note Saving Options::, for details.
  969.  
  970.    * The DDD command history will be saved in
  971.      `~/.ddd/sessions/SESSION/history' instead of `~/.ddd/history'.
  972.      *Note Command History::, for details.
  973.  
  974.    To make the current session inactive, open the _default session_
  975. named `[None]'.  *Note Resuming Sessions::, for details on opening
  976. sessions.
  977.  
  978.    ---------- Footnotes ----------
  979.  
  980.    (1) Only if a core file is included.
  981.  
  982.    (2) If a core file is _not_ to be included in the session, DDD data
  983. displays are saved as _deferred_; that is, they will be restored as
  984. soon as program execution reaches the scope in which they were created.
  985. *Note Creating Single Displays::, for details.
  986.  
  987. 
  988. File: ddd.info,  Node: Resuming Sessions,  Next: Deleting Sessions,  Prev: Saving Sessions,  Up: Sessions
  989.  
  990. Resuming Sessions
  991. -----------------
  992.  
  993.    To resume a previously saved session, select `File => Open Session'
  994. and choose a session name from the list.  After clicking on `Open', the
  995. entire DDD state will be restored from the given session.
  996.  
  997.    The session named `[None]' is the "default session" which is active
  998. when starting DDD.  To save options for default sessions, open the
  999. default session and save options.  *Note Saving Options::, for details.
  1000.  
  1001.    If a the restored session includes a core dump, the program being
  1002. debugged will be in the same state at the time the session was saved; in
  1003. particular, you can examine the program data.  However, you will not be
  1004. able to resume program execution since the process and its environment
  1005. (open files, resources, etc.) no longer exist.  However, you can restart
  1006. the program, re-using the restored breakpoints and data displays.
  1007.  
  1008.    Opening sessions also restores command definitions, buttons, display
  1009. shortcuts and the source tab width.  This way, you can maintain a
  1010. different set of definitions for each session.
  1011.  
  1012.    You can also specify a session to open when starting DDD.  To invoke
  1013. DDD with a session SESSION, use
  1014.  
  1015.      ddd --session SESSION
  1016.  
  1017.    There is also a shortcut that opens the session SESSION and invokes
  1018. the inferior debugger on an executable named SESSION (in case SESSION
  1019. cannot be opened):
  1020.  
  1021.      ddd =SESSION
  1022.  
  1023.    There is no need to give further command-line options when
  1024. restarting a session, as they will be overridden by the options saved
  1025. in the session.
  1026.  
  1027.    You can also use an X session manager such as `xsm' to save and
  1028. restore DDD sessions.(1) When being shut down by a session manager, DDD
  1029. saves its state under the name specified by the session manager;
  1030. resuming the X session makes DDD reload its saved state.
  1031.  
  1032.    ---------- Footnotes ----------
  1033.  
  1034.    (1) Requires X11R6 or later.
  1035.  
  1036. 
  1037. File: ddd.info,  Node: Deleting Sessions,  Next: Customizing Sessions,  Prev: Resuming Sessions,  Up: Sessions
  1038.  
  1039. Deleting Sessions
  1040. -----------------
  1041.  
  1042.    To delete sessions that are no longer needed, select `File => Open
  1043. Session' or `File => Save Session'.  Select the sessions you want to
  1044. delete and click on `Delete'.
  1045.  
  1046.    The default session `[None]' cannot be deleted.
  1047.  
  1048. 
  1049. File: ddd.info,  Node: Customizing Sessions,  Prev: Deleting Sessions,  Up: Sessions
  1050.  
  1051. Customizing Sessions
  1052. --------------------
  1053.  
  1054.    You can change the place where DDD saves its sessions by setting the
  1055. environment variable `DDD_SESSIONS' to the name of a directory.
  1056. Default is `~/.ddd/sessions/'.
  1057.  
  1058.    Where applicable, DDD supports a `gcore' command to obtain core
  1059. files of the running program.  You can enter its path via `Edit =>
  1060. Preferences => Helpers => Get Core File'.  Leave the value empty if you
  1061. have no `gcore' or similar command.
  1062.  
  1063.    This setting is tied to the following resource (*note Customizing::):
  1064.  
  1065.  - Resource: getCoreCommand (class GetCoreCommand)
  1066.      A command to get a core dump of a running process (typically,
  1067.      `gcore') `@FILE@' is replaced by the base name of the file to
  1068.      create; `@PID@' is replaced by the process id.  The output must be
  1069.      written to `@FILE@.@PID@'.
  1070.  
  1071.      Leave the value empty if you have no `gcore' or similar command.
  1072.  
  1073. 
  1074. File: ddd.info,  Node: Remote Debugging,  Next: Customizing Debugger Interaction,  Prev: Sessions,  Up: Invocation
  1075.  
  1076. Remote Debugging
  1077. ================
  1078.  
  1079.    You can have each of DDD, the inferior debugger, and the debugged
  1080. program run on different machines.
  1081.  
  1082. * Menu:
  1083.  
  1084. * Remote Host::                 Running DDD on a Remote Host
  1085. * Remote Debugger::             Using a Remote Inferior Debugger
  1086. * Remote Program::              Debugging a Remote Program
  1087.  
  1088. 
  1089. File: ddd.info,  Node: Remote Host,  Next: Remote Debugger,  Up: Remote Debugging
  1090.  
  1091. Running DDD on a Remote Host
  1092. ----------------------------
  1093.  
  1094.    You can run DDD on a remote host, using your current host as X
  1095. display.  On the remote host, invoke DDD as
  1096.  
  1097.      ddd -display DISPLAY
  1098.  
  1099. where DISPLAY is the name of the X server to connect to (for instance,
  1100. `HOSTNAME:0.0', where HOSTNAME is your host).
  1101.  
  1102.    Instead of specifying `-display DISPLAY', you can also set the
  1103. `DISPLAY' environment variable to DISPLAY.
  1104.  
  1105. 
  1106. File: ddd.info,  Node: Remote Debugger,  Next: Remote Program,  Prev: Remote Host,  Up: Remote Debugging
  1107.  
  1108. Using DDD with a Remote Inferior Debugger
  1109. -----------------------------------------
  1110.  
  1111.    In order to run the inferior debugger on a remote host, you need
  1112. `remsh' (called `rsh' on BSD systems) access on the remote host.
  1113.  
  1114.    To run the debugger on a remote host HOSTNAME, invoke DDD as
  1115.      ddd --host HOSTNAME REMOTE-PROGRAM
  1116.  
  1117.    If your remote USERNAME differs from the local username, use
  1118.  
  1119.      ddd --host HOSTNAME --login USERNAME REMOTE-PROGRAM
  1120.  
  1121. or
  1122.  
  1123.      ddd --host USERNAME@HOSTNAME REMOTE-PROGRAM
  1124.  
  1125. instead.
  1126.  
  1127.    There are a few _caveats_ in remote mode:
  1128.  
  1129.    * The remote debugger is started in your remote home directory.
  1130.      Hence, you must specify an absolute path name for REMOTE-PROGRAM
  1131.      (or a path name relative to your remote home directory).  Same
  1132.      applies to remote core files.  Also, be sure to specify a remote
  1133.      process id when debugging a running program.
  1134.  
  1135.    * The remote debugger is started non-interactively.  Some DBX
  1136.      versions have trouble with this.  If you do not get a prompt from
  1137.      the remote debugger, use the `--rhost' option instead of `--host'.
  1138.      This will invoke the remote debugger via an interactive shell on
  1139.      the remote host, which may lead to better results.
  1140.  
  1141.      Note: using `--rhost', DDD invokes the inferior debugger as soon
  1142.      as a shell prompt appears.  The first output on the remote host
  1143.      ending in a space character or `>' and not followed by a newline is
  1144.      assumed to be a shell prompt.  If necessary, adjust your shell
  1145.      prompt on the remote host.
  1146.  
  1147.    * To run the remote program, DDD invokes an `xterm' terminal
  1148.      emulator on the remote host, giving your current `DISPLAY'
  1149.      environment variable as address.  If the remote host cannot invoke
  1150.      `xterm', or does not have access to your X display, start DDD with
  1151.      the `--no-exec-window' option.  The program input/output will then
  1152.      go through the DDD debugger console.
  1153.  
  1154.    * In remote mode, all sources are loaded from the remote host; file
  1155.      dialogs scan remote directories.  This may result in somewhat
  1156.      slower operation than normal.
  1157.  
  1158.    * To help you find problems due to remote execution, run DDD with
  1159.      the `--trace' option.  This prints the shell commands issued by
  1160.      DDD on standard error.
  1161.  
  1162.    *Note Customizing Remote Debugging::, for customizing remote mode.
  1163.  
  1164. * Menu:
  1165.  
  1166. * Customizing Remote Debugging::
  1167.  
  1168. 
  1169. File: ddd.info,  Node: Customizing Remote Debugging,  Up: Remote Debugger
  1170.  
  1171. Customizing Remote Debugging
  1172. ............................
  1173.  
  1174.    When having the inferior debugger run on a remote host (*note Remote
  1175. Debugging::), all commands to access the inferior debugger as well as
  1176. its files must be run remotely.  This is controlled by the following
  1177. resources (*note Customizing::):
  1178.  
  1179.  - Resource: rshCommand (class RshCommand)
  1180.      The remote shell command to invoke TTY-based commands on remote
  1181.      hosts.  Usually, `remsh', `rsh', `ssh', or `on'.
  1182.  
  1183.  - Resource: listCoreCommand (class listCoreCommand)
  1184.      The command to list all core files on the remote host.  The string
  1185.      `@MASK@' is replaced by a file filter.  The default setting is:
  1186.  
  1187.           Ddd*listCoreCommand: \
  1188.           file @MASK@ | grep '.*:.*core.*' | cut -d: -f1
  1189.  
  1190.  - Resource: listDirCommand (class listDirCommand)
  1191.      The command to list all directories on the remote host.  The string
  1192.      `@MASK@' is replaced by a file filter.  The default setting is:
  1193.  
  1194.           Ddd*listDirCommand: \
  1195.           file @MASK@ | grep '.*:.*directory.*' | cut -d: -f1
  1196.  
  1197.  - Resource: listExecCommand (class listExecCommand)
  1198.      The command to list all executable files on the remote host.  The
  1199.      string `@MASK@' is replaced by a file filter.  The default setting
  1200.      is:
  1201.  
  1202.           Ddd*listExecCommand: \
  1203.           file @MASK@ | grep '.*:.*exec.*' \
  1204.             | grep -v  '.*:.*script.*' \
  1205.             | cut -d: -f1 | grep -v '.*\.o$'
  1206.  
  1207.  - Resource: listSourceCommand (class listSourceCommand)
  1208.      The command to list all source files on the remote host.  The
  1209.      string `@MASK@' is replaced by a file filter.  The default setting
  1210.      is:
  1211.  
  1212.           Ddd*listSourceCommand: \
  1213.           file @MASK@ | grep '.*:.*text.*' | cut -d: -f1
  1214.  
  1215. 
  1216. File: ddd.info,  Node: Remote Program,  Prev: Remote Debugger,  Up: Remote Debugging
  1217.  
  1218. Debugging a Remote Program
  1219. --------------------------
  1220.  
  1221.    The GDB debugger allows you to run the _debugged program_ on a
  1222. remote machine (called _remote target_), while GDB runs on the local
  1223. machine.
  1224.  
  1225.    *Note Remote Debugging: (gdb)Remote, for details.  Basically, the
  1226. following steps are required:
  1227.  
  1228.    * Transfer the executable to the remote target.
  1229.  
  1230.    * Start `gdbserver' on the remote target.
  1231.  
  1232.    * Start DDD using GDB on the local machine, and load the same
  1233.      executable using the GDB `file' command.
  1234.  
  1235.    * Attach to the remote `gdbserver' using the GDB `target remote'
  1236.      command.
  1237.  
  1238.    The local `.gdbinit' file is useful for setting up directory search
  1239. paths, etc.
  1240.  
  1241.    Of course, you can also combine DDD remote mode and GDB remote mode,
  1242. running DDD, GDB, and the debugged program each on a different machine.
  1243.  
  1244. 
  1245. File: ddd.info,  Node: Customizing Debugger Interaction,  Prev: Remote Debugging,  Up: Invocation
  1246.  
  1247. Customizing Interaction with the Inferior Debugger
  1248. ==================================================
  1249.  
  1250.    These settings control the interaction of DDD with its inferior
  1251. debugger.
  1252.  
  1253. * Menu:
  1254.  
  1255. * Debugger Invocation::
  1256. * Debugger Initialization::
  1257. * Debugger Communication::
  1258.  
  1259. 
  1260. File: ddd.info,  Node: Debugger Invocation,  Next: Debugger Initialization,  Up: Customizing Debugger Interaction
  1261.  
  1262. Invoking an Inferior Debugger
  1263. -----------------------------
  1264.  
  1265.    To choose the default inferior debugger, select `Edit => Preferences
  1266. => Startup => Debugger Type'.  You can
  1267.  
  1268.    * have DDD determine the appropriate inferior debugger automatically
  1269.      from its command-line arguments.  Set `Determine Automatically
  1270.      from Arguments' to enable.
  1271.  
  1272.    * have DDD start the debugger of your choice, as specified in
  1273.      `Debugger Type'.
  1274.  
  1275.    The following DDD resources control the invocation of the inferior
  1276. debugger (*note Customizing::).
  1277.  
  1278.  - Resource: autoDebugger (class AutoDebugger)
  1279.      If this is `on' (default), DDD will attempt to determine the
  1280.      debugger type from its arguments, possibly overriding the
  1281.      `debugger' resource (see below).  If this is `off', DDD will
  1282.      invoke the debugger specified by the `debugger' resource
  1283.      regardless of DDD arguments.
  1284.  
  1285.  - Resource: debugger (class Debugger)
  1286.      The type of the inferior debugger to invoke (`gdb', `dbx',
  1287.      `ladebug', `xdb', `jdb', `pydb', or `perl').
  1288.  
  1289.      This resource is usually set through the `--gdb', `--dbx',
  1290.      `--ladebug', `--xdb', `--jdb', `--pydb', and `--perl', options;
  1291.      *Note Options::, for details.
  1292.  
  1293.  - Resource: debuggerCommand (class DebuggerCommand)
  1294.      The name under which the inferior debugger is to be invoked.  If
  1295.      this string is empty (default), the debugger type (`debugger'
  1296.      resource) is used.
  1297.  
  1298.      This resource is usually set through the `--debugger' option;
  1299.      *Note Options::, for details.
  1300.  
  1301. 
  1302. File: ddd.info,  Node: Debugger Initialization,  Next: Debugger Communication,  Prev: Debugger Invocation,  Up: Customizing Debugger Interaction
  1303.  
  1304. Initializing the Inferior Debugger
  1305. ----------------------------------
  1306.  
  1307.    DDD uses a number of resources to initialize the inferior debugger
  1308. (*note Customizing::).
  1309.  
  1310. * Menu:
  1311.  
  1312. * GDB Initialization::
  1313. * DBX Initialization::
  1314. * XDB Initialization::
  1315. * JDB Initialization::
  1316. * PYDB Initialization::
  1317. * Perl Initialization::
  1318. * Finding a Place to Start::
  1319. * Opening the Selection::
  1320.  
  1321. 
  1322. File: ddd.info,  Node: GDB Initialization,  Next: DBX Initialization,  Up: Debugger Initialization
  1323.  
  1324. GDB Initialization
  1325. ..................
  1326.  
  1327.  - Resource: gdbInitCommands (class InitCommands)
  1328.      This string contains a list of newline-separated commands that are
  1329.      initially sent to GDB.  As a side-effect, all settings specified
  1330.      in this resource are considered fixed and cannot be changed
  1331.      through the GDB settings panel, unless preceded by white space.
  1332.      By default, the `gdbInitCommands' resource contains some settings
  1333.      vital to DDD:
  1334.  
  1335.             Ddd*gdbInitCommands: \
  1336.             set height 0\n\
  1337.             set width 0\n\
  1338.              set verbose off\n\
  1339.             set prompt (gdb) \n
  1340.  
  1341.      While the `set height', `set width', and `set prompt' settings are
  1342.      fixed, the `set verbose' settings can be changed through the GDB
  1343.      settings panel (although being reset upon each new DDD invocation).
  1344.  
  1345.      Do not use this resource to customize GDB; instead, use a personal
  1346.      `~/.gdbinit' file.  See your GDB documentation for details.
  1347.  
  1348.  - Resource: gdbSettings (class Settings)
  1349.      This string contains a list of newline-separated commands that are
  1350.      also initially sent to GDB.  Its default value is
  1351.  
  1352.             Ddd*gdbSettings: \
  1353.             set print asm-demangle on\n
  1354.  
  1355.      This resource is used to save and restore the debugger settings.
  1356.  
  1357.  - Resource: sourceInitCommands (class SourceInitCommands)
  1358.      If `on' (default), DDD writes all GDB initialization commands into
  1359.      a temporary file and makes GDB read this file, rather than sending
  1360.      each initialization command separately.  This results in faster
  1361.      startup (especially if you have several user-defined commands).  If
  1362.      `off', DDD makes GDB process each command separately.
  1363.  
  1364. 
  1365. File: ddd.info,  Node: DBX Initialization,  Next: XDB Initialization,  Prev: GDB Initialization,  Up: Debugger Initialization
  1366.  
  1367. DBX Initialization
  1368. ..................
  1369.  
  1370.  - Resource: dbxInitCommands (class InitCommands)
  1371.      This string contains a list of newline-separated commands that are
  1372.      initially sent to DBX.  By default, it is empty.
  1373.  
  1374.      Do not use this resource to customize DBX; instead, use a personal
  1375.      `~/.dbxinit' or `~/.dbxrc' file.  See your DBX documentation for
  1376.      details.
  1377.  
  1378.  - Resource: dbxSettings (class Settings)
  1379.      This string contains a list of newline-separated commands that are
  1380.      also initially sent to DBX.  By default, it is empty.
  1381.  
  1382. 
  1383. File: ddd.info,  Node: XDB Initialization,  Next: JDB Initialization,  Prev: DBX Initialization,  Up: Debugger Initialization
  1384.  
  1385. XDB Initialization
  1386. ..................
  1387.  
  1388.  - Resource: xdbInitCommands (class InitCommands)
  1389.      This string contains a list of newline-separated commands that are
  1390.      initially sent to XDB.  By default, it is empty.
  1391.  
  1392.      Do not use this resource to customize DBX; instead, use a personal
  1393.      `~/.xdbrc' file.  See your XDB documentation for details.
  1394.  
  1395.  - Resource: xdbSettings (class Settings)
  1396.      This string contains a list of newline-separated commands that are
  1397.      also initially sent to XDB.  By default, it is empty.
  1398.  
  1399. 
  1400. File: ddd.info,  Node: JDB Initialization,  Next: PYDB Initialization,  Prev: XDB Initialization,  Up: Debugger Initialization
  1401.  
  1402. JDB Initialization
  1403. ..................
  1404.  
  1405.  - Resource: jdbInitCommands (class InitCommands)
  1406.      This string contains a list of newline-separated commands that are
  1407.      initially sent to JDB.  This resource may be used to customize
  1408.      JDB.  By default, it is empty.
  1409.  
  1410.  - Resource: jdbSettings (class Settings)
  1411.      This string contains a list of newline-separated commands that are
  1412.      also initially sent to JDB.  By default, it is empty.
  1413.  
  1414.      This resource is used by DDD to save and restore JDB settings.
  1415.  
  1416. 
  1417. File: ddd.info,  Node: PYDB Initialization,  Next: Perl Initialization,  Prev: JDB Initialization,  Up: Debugger Initialization
  1418.  
  1419. PYDB Initialization
  1420. ...................
  1421.  
  1422.  - Resource: pydbInitCommands (class InitCommands)
  1423.      This string contains a list of newline-separated commands that are
  1424.      initially sent to PYDB.  By default, it is empty.
  1425.  
  1426.      This resource may be used to customize PYDB.
  1427.  
  1428.  - Resource: pydbSettings (class Settings)
  1429.      This string contains a list of newline-separated commands that are
  1430.      also initially sent to PYDB.  By default, it is empty.
  1431.  
  1432.      This resource is used by DDD to save and restore PYDB settings.
  1433.  
  1434. 
  1435. File: ddd.info,  Node: Perl Initialization,  Next: Finding a Place to Start,  Prev: PYDB Initialization,  Up: Debugger Initialization
  1436.  
  1437. Perl Initialization
  1438. ...................
  1439.  
  1440.  - Resource: perlInitCommands (class InitCommands)
  1441.      This string contains a list of newline-separated commands that are
  1442.      initially sent to the Perl debugger.  By default, it is empty.
  1443.  
  1444.      This resource may be used to customize the Perl debugger.
  1445.  
  1446.  - Resource: perlSettings (class Settings)
  1447.      This string contains a list of newline-separated commands that are
  1448.      also initially sent to the Perl debugger.  By default, it is empty.
  1449.  
  1450.      This resource is used by DDD to save and restore Perl debugger
  1451.      settings.
  1452.  
  1453. 
  1454. File: ddd.info,  Node: Finding a Place to Start,  Next: Opening the Selection,  Prev: Perl Initialization,  Up: Debugger Initialization
  1455.  
  1456. Finding a Place to Start
  1457. ........................
  1458.  
  1459.  - Resource: initSymbols (class InitSymbols)
  1460.      When loading an executable, DDD queries the inferior debugger for
  1461.      the initial source location--typically the `main' function.  If
  1462.      this location is not found, DDD tries other symbols from this
  1463.      newline-separated list.  The default value makes DDD look for a
  1464.      variety of main functions (especially FORTRAN main functions):
  1465.           main\n\
  1466.           MAIN\n\
  1467.           main_\n\
  1468.           MAIN_\n\
  1469.           main__\n\
  1470.           MAIN__\n\
  1471.           _main\n\
  1472.           _MAIN\n\
  1473.           __main\n\
  1474.           __MAIN
  1475.  
  1476. 
  1477. File: ddd.info,  Node: Opening the Selection,  Prev: Finding a Place to Start,  Up: Debugger Initialization
  1478.  
  1479. Opening the Selection
  1480. .....................
  1481.  
  1482.  - Resource: openSelection (class OpenSelection)
  1483.      If this is `on', DDD invoked without argument checks whether the
  1484.      current selection or clipboard contains the file name or URL of an
  1485.      executable program.  If this is so, DDD will automatically open
  1486.      this program for debugging.  If this resource is `off' (default),
  1487.      DDD invoked without arguments will always start without a debugged
  1488.      program.
  1489.  
  1490.